home *** CD-ROM | disk | FTP | other *** search
/ Speccy ClassiX 1998 / Speccy ClassiX 98.iso / amiga_system / the_aminet / dev / gcc / ixemulsrc.lha / ixemul-41.4 / library / tracecntl.c < prev    next >
C/C++ Source or Header  |  1995-05-28  |  9KB  |  281 lines
  1. /*
  2.  *  This file is part of ixemul.library for the Amiga.
  3.  *  Copyright (C) 1991, 1992  Markus M. Wild
  4.  *
  5.  *  This library is free software; you can redistribute it and/or
  6.  *  modify it under the terms of the GNU Library General Public
  7.  *  License as published by the Free Software Foundation; either
  8.  *  version 2 of the License, or (at your option) any later version.
  9.  *
  10.  *  This library is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  *  Library General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU Library General Public
  16.  *  License along with this library; if not, write to the Free
  17.  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  *
  19.  *  tracecntl.c,v 1.1.1.1 1994/04/04 04:29:49 amiga Exp
  20.  *
  21.  *  tracecntl.c,v
  22.  * Revision 1.1.1.1  1994/04/04  04:29:49  amiga
  23.  * Initial CVS check in.
  24.  *
  25.  *  Revision 1.6  1993/11/05  22:03:32  mwild
  26.  *  treat vfork2 same as vfork
  27.  *
  28.  *  Revision 1.5  1992/08/09  21:01:09  amiga
  29.  *  import sysbase
  30.  *
  31.  *  Revision 1.4  1992/07/04  19:23:16  mwild
  32.  *  double the number of passed parameters. Probably still not enough for weird
  33.  *  cases, but I can't do much about that...
  34.  *
  35.  * Revision 1.3  1992/05/22  01:51:07  mwild
  36.  * all common double returning functions are _JMP or they won't work
  37.  *
  38.  * Revision 1.2  1992/05/18  12:24:20  mwild
  39.  * new way of getting at the result of a function. Do the call from
  40.  * inside the handler and tell the library call hook to not call the
  41.  * function again (TRACE_ACTION_RTS). Removed trace_exit() handler.
  42.  *
  43.  * Revision 1.1  1992/05/14  19:55:40  mwild
  44.  * Initial revision
  45.  *
  46.  */
  47.  
  48. #define KERNEL
  49. #include "ixemul.h"
  50. #include "kprintf.h"
  51.  
  52. #include <sys/tracecntl.h>
  53.  
  54. #ifdef TRACE_LIBRARY
  55. struct ExecBase *SysBase;
  56.  
  57. static struct List packets = {
  58.   (struct Node *) &packets.lh_Tail, 0, (struct Node *) &packets.lh_Head,
  59. };
  60.  
  61. static struct SignalSemaphore psem;
  62. static sem_initialized = 0;
  63.  
  64. /* for each function traced, the trace_entry() function decides whether
  65.    the trace_exit() function is invoked or not.
  66.    If trace_entry() returns false, trace_exit() is not invoked.
  67.  
  68.    NOTE: having setjmp, vfork and the like invoke trace_exit will *NOT*
  69.          work and will cause crashes!!
  70.  
  71.    Since I consider placing break points just to get the return value
  72.    a bit overkill, I'll take a less optimal solution: I copy 8 args, this
  73.    will do for 99% of all cases, and some nasty printf() style call will
  74.    probably fail if tracing is enabled, so what ;-)) */
  75.  
  76. int
  77. trace_entry (int scall, int (*func)(int, ...), void *ret_addr,
  78.          int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8,
  79.          int a9, int aa, int ab, int ac, int ad, int ae, int af)
  80. {
  81.   struct trace_packet *tp, *ntp;
  82.   struct Task *me = FindTask (0);
  83.   int te_action, handler_active;
  84.   int omask;
  85.  
  86.   /* for safety, don't do anything if running in Forbid() or Disable() */
  87.   if (SysBase->TDNestCnt >= 0 || SysBase->IDNestCnt >= 0)
  88.     return TRACE_ACTION_JMP;
  89.  
  90.   /* have to do this here, or the handler may get into a deadlock
  91.      situation when trying to obtain the semaphore */
  92.   if (u.u_trace_flags)
  93.     return TRACE_ACTION_JMP;
  94.  
  95.   /* get default action value */  
  96.   switch (scall)
  97.     {
  98.       case SYS_abort:
  99.       case SYS_exit:
  100.       case SYS_longjmp:
  101.       case SYS_setjmp:        /* can return twice ! */
  102.       case SYS_siglongjmp:
  103.       case SYS_sigreturn:
  104.       case SYS_sigsetjmp:    /* "" */
  105.       case SYS__exit:
  106.       case SYS__longjmp:
  107.       case SYS__setjmp:        /* "" */
  108.       case SYS_vfork:        /* "" */
  109.       case SYS_vfork2:        /* "" */
  110.       case SYS_vfork_resume:    /* does longjmp-y thing... */
  111.       case SYS_execve:
  112.       case SYS_ix_geta4:    /* special, result is in A4, not D0 ;-)) */
  113.       case SYS_ix_check_cpu:    /* may not return (but isn't used currently ;-)) */
  114.       case SYS_ix_startup:    /* those two call longjmp thru _exit */
  115.       case SYS_ix_exec_entry:
  116.       case SYS_fork:
  117.       case SYS_floor:        /* have all functions returning more than */
  118.       case SYS_ceil:        /* 4 bytes be called JMP'y */
  119.       case SYS_atof:
  120.       case SYS_frexp:
  121.       case SYS_modf:      
  122.       case SYS_ldexp:
  123.       case SYS_atan ... SYS_fabs:    /* all the trigo stuff from *transbase.. */
  124.       case SYS_strtod:
  125.     te_action = TRACE_ACTION_JMP;
  126.     break;
  127.  
  128.       default:
  129.     te_action = TRACE_ACTION_JSR;
  130.     break;
  131.     }
  132.  
  133.   /* don't use syscall() here.. */
  134.   omask = sigsetmask (~0);
  135.   if (! sem_initialized)
  136.     {
  137.       sem_initialized = 1;
  138.       InitSemaphore (& psem);
  139.     }
  140.   ObtainSemaphore (& psem);
  141.   handler_active = 0;
  142.   for (tp  = (struct trace_packet *) packets.lh_Head;
  143.        ntp = (struct trace_packet *) tp->tp_message.mn_Node.ln_Succ;
  144.        tp  = ntp)
  145.     {
  146.       if ((!tp->tp_pid || tp->tp_pid == (pid_t) me) &&
  147.             (!tp->tp_syscall || tp->tp_syscall == scall))
  148.     {
  149.       Remove ((struct Node *) tp);
  150.  
  151.       tp->tp_is_entry = 1;
  152.       tp->tp_argv = &scall;
  153.       tp->tp_errno = u.u_errno;
  154.       /* provide the default for the handler to (possibly) override */
  155.       tp->tp_action = te_action;
  156.       /* wanted to use u.u_sync_mp here, but this leads to some
  157.          deadlock situations when the port is used for packets.. */
  158.       tp->tp_message.mn_ReplyPort = (struct MsgPort *) me;
  159.       SetSignal (0, SIGBREAKF_CTRL_E);
  160.           PutMsg (tp->tp_tracer_port, (struct Message *) tp);
  161.       Wait (SIGBREAKF_CTRL_E);
  162.       /* the last handler wins ;-)) */
  163.       te_action = tp->tp_action;
  164.       handler_active = 1;
  165.  
  166.       /* should be safe.. */
  167.       AddHead (&packets, (struct Node *) tp);
  168.     }
  169.     }
  170.   ReleaseSemaphore (& psem);
  171.   sigsetmask (omask);
  172.  
  173.   if (! handler_active)
  174.     te_action = TRACE_ACTION_JMP;
  175.  
  176.   switch (te_action)      
  177.     {
  178.     case TRACE_ACTION_ABORT:
  179.       abort();
  180.  
  181.     default:
  182.     case TRACE_ACTION_JMP:
  183.       return TRACE_ACTION_JMP;
  184.       
  185.     case TRACE_ACTION_JSR:
  186.       {
  187.         int result, error;
  188.  
  189.         /* we now know that there is at least one trace handler
  190.            interested in this result, so do the extra overhead of
  191.            calling with (excess) argument copying */
  192.     result = func (a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af);
  193.     error  = errno;
  194.  
  195.     /* replace the function address with the result */
  196.     *(int *)&func = result;
  197.     
  198.     /* and repeat the process of calling the trace handler(s) */
  199.     omask = sigsetmask (~0);
  200.         ObtainSemaphore (& psem);
  201.         for (tp  = (struct trace_packet *) packets.lh_Head;
  202.              ntp = (struct trace_packet *) tp->tp_message.mn_Node.ln_Succ;
  203.              tp  = ntp)
  204.           {
  205.             if ((!tp->tp_pid || tp->tp_pid == (pid_t) me) &&
  206.                   (!tp->tp_syscall || tp->tp_syscall == scall))
  207.           {
  208.             Remove ((struct Node *) tp);
  209.  
  210.         tp->tp_is_entry = 0;
  211.         tp->tp_argv = &scall;
  212.         errno = error;
  213.         KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  214.         tp->tp_errno = u.u_errno;
  215.         tp->tp_message.mn_ReplyPort = (struct MsgPort *) me;
  216.         SetSignal (0, SIGBREAKF_CTRL_E);
  217.         PutMsg (tp->tp_tracer_port, (struct Message *) tp);
  218.         Wait (SIGBREAKF_CTRL_E);
  219.  
  220.         error = errno;
  221.         /* should be safe.. */
  222.         AddHead (&packets, (struct Node *) tp);
  223.           }
  224.       }
  225.     ReleaseSemaphore (& psem);
  226.     sigsetmask (omask);
  227.     errno = error;
  228.     KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  229.       }
  230.       /* fall into */
  231.  
  232.     case TRACE_ACTION_RTS:
  233.       return TRACE_ACTION_RTS;
  234.     }
  235. }
  236.  
  237. #endif /* TRACE_LIBRARY */
  238.  
  239.  
  240. int
  241. tracecntl (enum trace_cmd cmd, struct trace_packet *tp)
  242. {
  243. #ifndef TRACE_LIBRARY
  244.   errno = ENOSYS;
  245.   KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  246.   return -1;
  247. #else
  248.   switch (cmd)
  249.     {
  250.     case TRACE_INSTALL_HANDLER:
  251.       ix_lock_base ();
  252.       tp->tp_message.mn_Node.ln_Type = NT_MESSAGE;
  253.       tp->tp_message.mn_Length = sizeof (struct trace_packet);
  254.       ObtainSemaphore (& psem);
  255.       AddTail (&packets, (struct Node *) tp);
  256.       ReleaseSemaphore (& psem);
  257.       ix_unlock_base ();
  258.       u.u_trace_flags = 1;
  259.       errno = 0;
  260.       KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  261.       return errno;
  262.  
  263.     case TRACE_REMOVE_HANDLER:
  264.       ix_lock_base ();
  265.       ObtainSemaphore (& psem);
  266.       Remove ((struct Node *) tp);
  267.       ReleaseSemaphore (& psem);
  268.       ix_unlock_base ();
  269.       u.u_trace_flags = 0;
  270.       errno = 0;
  271.       KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  272.       return errno;
  273.       
  274.     default:
  275.       errno = EINVAL;
  276.       KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  277.       return -1;
  278.     }
  279. #endif
  280. }
  281.